package practise.dynamicproxy;

/**
 * @author: 默苍璃
 * @date: 2024-11-06 23:13
 */
public class TestUser {
    public static void main(String[] args) {
        User user = new User();
        user.setName("zhangsan");
        User user1 = user;
        user1.setName("lisi");

        System.out.println(user.getName());
    }


    /**
     * 在你的 Java 代码中，输出结果为 "lisi" 的原因在于对象引用的特性。让我们详细解释一下这段代码的执行过程：
     *
     * ### 代码分析
     *
     * ```java
     * public class TestUser {
     *     public static void main(String[] args) {
     *         User user = new User();  // 1. 创建一个新的 User 对象，并将引用赋值给 user
     *         user.setName("zhangsan");  // 2. 设置 user 对象的 name 属性为 "zhangsan"
     *
     *         User user1 = user;  // 3. 将 user 引用赋值给 user1，此时 user1 和 user 指向同一个对象
     *         user1.setName("lisi");  // 4. 通过 user1 修改对象的 name 属性为 "lisi"
     *
     *         System.out.println(user.getName());  // 5. 输出 user 对象的 name 属性
     *     }
     * }
     * ```
     *
     *
     * ### 详细步骤
     *
     * 1. **创建对象并赋值**：
     *    ```java
     *    User user = new User();
     *    ```
     *
     *    - 这行代码创建了一个新的 `User` 对象，并将该对象的引用赋值给变量 `user`。
     *
     * 2. **设置属性**：
     *    ```java
     *    user.setName("zhangsan");
     *    ```
     *
     *    - 通过 `user` 引用，将 `User` 对象的 `name` 属性设置为 "zhangsan"。
     *
     * 3. **引用赋值**：
     *    ```java
     *    User user1 = user;
     *    ```
     *
     *    - 这行代码将 `user` 引用赋值给 `user1`。此时，`user1` 和 `user` 都指向同一个 `User` 对象。
     *
     * 4. **修改属性**：
     *    ```java
     *    user1.setName("lisi");
     *    ```
     *
     *    - 通过 `user1` 引用，将 `User` 对象的 `name` 属性设置为 "lisi"。由于 `user1` 和 `user`
     *    指向同一个对象，所以这个修改会影响到 `user` 引用的对象。
     *
     * 5. **输出属性**：
     *    ```java
     *    System.out.println(user.getName());
     *    ```
     *
     *    - 通过 `user` 引用，输出 `User` 对象的 `name` 属性。由于 `user` 和 `user1` 指向同一个对象，
     *    `name` 属性已经被修改为 "lisi"，所以输出结果为 "lisi"。
     *
     * ### 图解
     *
     * ```
     * 初始状态:
     * user -> [User对象] (name: null)
     *
     * user.setName("zhangsan"):
     * user -> [User对象] (name: "zhangsan")
     *
     * User user1 = user:
     * user -> [User对象] (name: "zhangsan")
     * user1 -> [User对象] (name: "zhangsan")
     *
     * user1.setName("lisi"):
     * user -> [User对象] (name: "lisi")
     * user1 -> [User对象] (name: "lisi")
     *
     * System.out.println(user.getName()):
     * 输出: "lisi"
     * ```
     *
     *
     * ### 总结
     *
     * - **对象引用**：`user1 = user` 使得 `user1` 和 `user` 指向同一个 `User` 对象。
     * - **属性修改**：通过 `user1` 修改对象的属性，会影响到 `user` 引用的对象。
     * - **输出结果**：最终 `user` 引用的对象的 `name` 属性为 "lisi"，因此输出结果为 "lisi"。
     *
     * 希望这能帮助你理解为什么输出结果是 "lisi"。
     */

}
